package com.nomito.minimito.controller.front;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.nomito.minimito.common.constant.OperatorFriendRequestTypeEnum;
import com.nomito.minimito.common.constant.SearchFriendsStatusEnum;
import com.nomito.minimito.common.utils.R;
import com.nomito.minimito.entity.ImRequestEntity;
import com.nomito.minimito.entity.ImUserEntity;
import com.nomito.minimito.service.ImFriendService;
import com.nomito.minimito.service.ImRequestService;
import com.nomito.minimito.service.ImUserService;
import com.nomito.minimito.vo.FriendRequestVo;
import com.nomito.minimito.vo.MyFriendsVO;
import com.nomito.minimito.vo.UserVo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ui.Model;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @author 凌月青缃
 * @date 2021/5/10
 */
@Api(tags = "好友接口")
@RestController
@CrossOrigin
@RequestMapping("/front/friend")
public class FFriendController {


    @Autowired
    ImRequestService friendRequestService;
    @Autowired
    ImFriendService friendService;
    @Autowired
    ImUserService userService;



    /**
     * 搜索好友的请求方法，按理说非空验证在前端和后端都需要进行，不过我们为了性能考虑，在前端进行
     * 搜索已存在的好友
     * 技术有两种，一种是使用Mysql的，一种是使用ES，那么后期将启用ES版本
     */
    @GetMapping("/searchFriend")
    @ApiOperation(value = "查询不存在的好友的方法，存在的发消息，不存在的发对象信息")
    @ApiImplicitParam(name = "friendUsername",value = "不可以是昵称，只能是朋友账号username",required = true)
    public R searchFriend (Long myUserId, String friendUsername){
        /**
         * 前置条件：
         * 1.搜索的用户如果不存在，则返回【无此用户】
         * 2.搜索的账号如果是你自己，则返回【不能添加自己】
         * 3.搜索的朋友已经是你好友，返回【该用户已经是你的好友】
         */
        Integer status = friendService.preconditionSearchFriend(myUserId, friendUsername);
        if(status== SearchFriendsStatusEnum.SUCCESS.code){
            //查询是否存在
            ImUserEntity user = userService.getOne(new QueryWrapper<ImUserEntity>().select("id", "username", "nickname").eq("username", friendUsername));
            UserVo userVo = new UserVo();
            BeanUtils.copyProperties(user,userVo);
            return R.ok().put("data",userVo);
        }else{
            return R.error().put("msg",SearchFriendsStatusEnum.getMsgByKey(status));
        }
    }
    /**
     * 发送添加好友请求的方法
     */
    @ApiOperation(value = "发送添加好友请求的方法")
    @ApiImplicitParam(name = "username",value = "别人的账号",required = true)
    @GetMapping("/addFriendRequest")
    public R addFriendRequest(@RequestParam("myUserId") Long myUserId,@RequestParam("username")String username,@RequestParam("requestMsg")String requestMsg){
        if (StringUtils.isEmpty(myUserId) || StringUtils.isEmpty(username)){
            return R.error().put("msg","好友消息为空！");
        }
        /**
         * 前置条件：
         * 1.搜索的用户如果不存在，则返回【无此用户】
         * 2.搜索的账号如果是你自己，则返回【不能添加自己】
         * 3.搜索的朋友已经是你好友，返回【该用户已经是你的好友】
         */
        Integer status = friendService.preconditionSearchFriend(myUserId, username);
        if(status== SearchFriendsStatusEnum.SUCCESS.code){
            //查询是否存在
            friendRequestService.sendFriendRequest(myUserId, username, requestMsg);
        }else{
            return R.error().put("msg",SearchFriendsStatusEnum.getMsgByKey(status));
        }
        return R.ok().put("msg","好友请求已发送~");

    }
    /**
     * 好友请求列表查询
     */
    @ApiOperation(value = "好友请求列表查询")
    @ApiImplicitParam(name = "acceptUserId",value = "我的id",required = true)
    @GetMapping("/queryFriendRequest")
    public R queryFriendRequest(Long acceptUserId){
        List<FriendRequestVo> list = friendRequestService.queryFriendRequestList(acceptUserId);
        return R.ok().setData(list);
    }

    /**
     * 好友请求处理映射,0忽略，1接受
     */
    @ApiOperation(value = "好友请求处理映射")
    @ApiImplicitParam(name = "operType",value = "操作请求,0忽略，1接受",required = true)
    @GetMapping("friendRequestOperation")
    public R friendRequestOperation(Long acceptUserId, Long sendUserId, Integer operType){
        if (operType == OperatorFriendRequestTypeEnum.IGNORE.type){
            //对好友请求表中的数据进行删除
            friendRequestService.remove(new QueryWrapper<ImRequestEntity>().eq("accept_user_id",acceptUserId).eq("send_user_id",sendUserId));
        }else if (operType == OperatorFriendRequestTypeEnum.PASS.type){
            //通过请求，向好友表中添加两条记录，一条对接收者而言，一条对发送者而言，同时删除好友请求表中对应的记录
            friendService.passFriendRequest(sendUserId,acceptUserId);
        }
        //查询好友表中的列表数据
        List<MyFriendsVO> myFriends = friendService.queryMyFriends(acceptUserId);
        return R.ok().put("data",myFriends);
    }

    /**
     * 好友列表查询
     */
    @ApiOperation(value = "好友列表查询")
    @GetMapping("/myFriends")
    public R myFriends(Long userId){
        if (StringUtils.isEmpty(userId)){
            return R.error("用户id为空");
        }
        //数据库查询好友列表
        List<MyFriendsVO> myFriends = friendService.queryMyFriends(userId);
        return R.ok().setData(myFriends);
    }

    /**
     * 删除好友
     */
    @ApiOperation(value = "删除好友")
    @GetMapping("/deleteFriends")
    public R deleteFriends(Long myId,Long myfriendId){
        //数据库查询好友列表
        boolean b = friendService.deleteForTwoUser(myId,myfriendId);
        return R.ok();
    }






}
